l'algorithme Karplus-Strong

principes du son numérique

-analogique/numerique : encodage du son
-la frequence d'echantillonage (20000hz). correspond à la qualité du son
-la quantification : nobre de valeurs possibles
-le buffer et sa taille -> N=fech/f

l'algorithme karplus-strong : création numérique de sons

principe de l'algo (file):

-creation d'un buffer de données aléatoires à partir d'une fréquence donnée
-calcul de la moyenne pondérée du 1er et 2eme echantillon, et ajout de cette valeur à la fin
-effacage du 1er element, et ajout de celui-ci au tableau du son final
-fin quand on possede assez d'echantillon pour creer un son d'une durée donnée

moyenne pondérée de A et B, de poids α et β, : m = ( 1 / α + β ).(α.a + β.b)

le code

from random import randint
from module import *
from files import *

def creer_echantillon(objet):
    '''
    creation d'un fichier audio à partir du tableau de donnees
    '''
    write_wav("fichier_son",objet.son,objet.fech)

def remplir_buffer(objet):
    '''
    remplis le buffer de chaque son avec des valeurs aléatoires plus ou moins éloignées de la fréquence principale
    '''
    for i in range(objet.N):
        objet.buffer.enfiler(randint(objet.f-1000,objet.f+1000))


class Corde:
    def __init__(self,f,alpha=0.8,fech=20000):
        self.fech=fech
        self.N=int(fech/f)#taille du buffer nécessaire
        self.f=f#fréquence du son
        self.buffer=FileOptim()
        self.son=[]#tableau qui contiendras le son final
        self.alpha=alpha#valeurs servant a calculer la moyenne pondérée
        self.beta=1-alpha

    def algorithme(self):
        '''
        l'algorithme karplus-strong
        '''
        remplir_buffer(self)#on remplit le buffer dans un premier temps
        premier=self.buffer.defiler().valeur
        for i in range(50000):#on fait tourner l'algorithme un certain nombre de fois, qui définit la durée du son
            premier2=self.buffer.defiler().valeur
            moyenne=(1/(self.alpha+self.beta))*((self.alpha*premier)+(self.beta*premier2))#moyenne pondérée
            self.son.append(premier)
            self.buffer.enfiler(moyenne)
            premier=premier2
        creer_echantillon(self)#on crée le fichier audio a partir des valeurs obtenues avec l'algorithme

class Percu:
    def __init__(self,f,alpha=0.8,fech=20000):
        self.fech=fech
        self.N=int(fech/f)
        self.f=f
        self.buffer=FileOptim()
        self.son=[]
        self.alpha=alpha
        self.beta=1-alpha

    def algorithme(self):
        remplir_buffer(self)
        premier=self.buffer.defiler().valeur
        for i in range(50000):
            proba=randint(0,100)
            premier2=self.buffer.defiler().valeur
            moyenne=(1/(self.alpha+self.beta))*((self.alpha*premier)+(self.beta*premier2))
            self.son.append(premier)
            if proba<50:#pour creer une precussion, on a une chance sur deux de prendre l'inverse de la moyenne pondérée
                self.buffer.enfiler(moyenne)
            else:
                self.buffer.enfiler(1/moyenne)
            premier=premier2
        creer_echantillon(self)

s1=Corde(300)
s1.algorithme()
#s2=Percu(300)
#s2.algorithme()